{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nn模块内所包含的基本损失函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 损失函数                      | 说明                                                      | 适用任务                |  \n",
    "|-------------------------------|-----------------------------------------------------------|-------------------------|  \n",
    "| `nn.MSELoss`                  | 均方误差损失。适用于回归问题。                           | 回归                    |  \n",
    "| `nn.L1Loss`                   | 平均绝对误差损失。对异常值不敏感。                       | 回归                    |  \n",
    "| `nn.SmoothL1Loss`            | 平滑 L1 损失，在 L1 和 L2 损失之间平滑过渡。             | 回归                    |  \n",
    "| `nn.CrossEntropyLoss`         | 交叉熵损失，适用于多类分类问题。                         | 多类分类                |  \n",
    "| `nn.BCELoss`                  | 二元交叉熵损失。适用于二分类任务。                       | 二分类                  |  \n",
    "| `nn.BCEWithLogitsLoss`       | 数值稳定的二元交叉熵损失与 Sigmoid 组合。               | 二分类                  |  \n",
    "| `nn.MultiLabelMarginLoss`     | 多标签边际损失。适用于多标签分类任务。                   | 多标签分类              |  \n",
    "| `nn.MultiLabelSoftMarginLoss` | 适合多标签分类的边际损失。                               | 多标签分类              |  \n",
    "| `nn.HingeEmbeddingLoss`       | 用于嵌入的损失，适合某种类型的二分类任务。                | 二分类                  |  \n",
    "| `nn.KLDivLoss`                | Kullback-Leibler 散度损失，测量两个概率分布的差异。       | 概率分布比较            |  \n",
    "| `nn.CosineEmbeddingLoss`      | 衡量样本之间的余弦相似度。                               | 度量学习、推荐系统      |  \n",
    "| `nn.TripletMarginLoss`        | 三元边际损失，强制相似样本之间的距离小于不相似样本之间的距离。 | 度量学习                |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "optime内包含的优化器函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 优化器                          | 说明                                                      | 适用场景                     |  \n",
    "|---------------------------------|-----------------------------------------------------------|------------------------------|  \n",
    "| `optim.SGD`                     | 随机梯度下降（Stochastic Gradient Descent）。基本的优化器。 | 简单的学习任务，且对大规模数据有效 |  \n",
    "| `optim.Adam`                    | 结合动量和自适应学习率的优化器。通常表现优异。           | 大多数深度学习任务              |  \n",
    "| `optim.AdamW`                   | Adam优化器的改进版本，包含权重衰减（Weight Decay）作为正则化。 | 需要正则化的深度学习任务        |  \n",
    "| `optim.RMSprop`                 | 自适应学习率优化器，对于非平稳目标有效。                 | 循环神经网络（RNN）等时间序列任务 |  \n",
    "| `optim.Adadelta`                | 可以自适应调整学习率，基于窗口大小来计算累计梯度。       | 需要自适应学习率的场景        |  \n",
    "| `optim.LBFGS`                   | 拟牛顿法的优化器，适用于小规模数据集与低阶问题。         | 光滑且可微的任务              |  \n",
    "| `optim.ASGD`                    | 增量式随机梯度下降，适用于大规模数据集。                 | 大规模学习任务               |  \n",
    "| `optim.NAdam`                   | Nesterov Adam优化器，结合了动量和自适应学习率。           | 需要快速收敛的任务           |  \n",
    "| `optim.SparseAdam`              | Adam优化器的稀疏版本，适合处理稀疏梯度问题。             | 自然语言处理等稀疏任务       |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| **API 模块**               | **功能描述**                                                      |  \n",
    "|---------------------------|------------------------------------------------------------------|  \n",
    "| **`torch`**               | 创建和操作张量，数学运算                                          |  \n",
    "| **`torch.autograd`**      | 自动求导，支持反向传播                                          |  \n",
    "| **`torch.nn`**            | 构建神经网络，提供层、激活函数等组件，预定义模型               |  \n",
    "| **`torch.nn` (损失函数)** | 计算损失，如 `MSELoss`, `CrossEntropyLoss`                      |  \n",
    "| **`torch.optim`**         | 实现优化算法，如 `SGD`, `Adam`，更新模型参数                    |  \n",
    "| **`torch.utils.data`**    | 加载和处理数据，提供 `Dataset` 和 `DataLoader`                 |  \n",
    "| **CUDA**                  | 支持 GPU 加速计算，提供与 GPU 的接口                            |  \n",
    "| **模型保存与加载**        | 使用 `torch.save()` 和 `torch.load()` 保存和加载模型状态        |  \n",
    "| **TorchScript**           | 模型的序列化和优化，使用 JIT 编译器支持跨平台运行               |  \n",
    "| **可视化工具**            | 集成 TensorBoard 监控训练过程，提供图像数据集处理的 `torchvision` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "修改数据输入的批量数据，训练次数，全连接层，损失函数，优化器，实际的训练数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch  \n",
    "import torch.nn as nn  \n",
    "import torch.optim as optim  \n",
    "from torch.utils.data import DataLoader, TensorDataset  #将张量组合在一块，批量加载数据\n",
    "# TensorDataset 将特征和标签张量关联在一起，方便我们进行监督学习。\n",
    "# DataLoader 负责从 Dataset 中按批量加载数据，支持多线程加速和数据打乱，为训练过程提供高效的数据输入。\n",
    "\n",
    "# 生成随机数据  \n",
    "# 特征数为10，样本数量为100  \n",
    "X = torch.randn(100, 10)  # 随机生成100个样本，每个样本10个特征  \n",
    "y = torch.randn(100, 1)   # 随机生成100个目标值，每个目标值为1个数  \n",
    "\n",
    "# 创建一个 TensorDataset 对象，方便后续使用 DataLoader  \n",
    "dataset = TensorDataset(X, y)  \n",
    "\n",
    "# 创建 DataLoader，用于批量加载数据  \n",
    "dataloader = DataLoader(dataset, batch_size=16, shuffle=True)  # 每批数据16个样本, 随机打乱顺序  \n",
    "\n",
    "# 定义一个简单的神经网络模型  \n",
    "class SimpleNN(nn.Module):  \n",
    "    # 初始化网络结构  \n",
    "    def __init__(self):  \n",
    "        super(SimpleNN, self).__init__()  # 调用父类构造函数  \n",
    "        self.fc1 = nn.Linear(10, 5)      # 第一个全连接层，输入10个特征，输出5个特征  \n",
    "        self.fc2 = nn.Linear(5, 1)        # 第二个全连接层，输入5个特征，输出1个特征  \n",
    "\n",
    "    # 定义前向传播过程  \n",
    "    def forward(self, x):  \n",
    "        x = torch.relu(self.fc1(x))  # 第一层的输出经过 ReLU 激活  \n",
    "        return self.fc2(x)           # 第二层的输出  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Parameter containing:\n",
      "tensor([[-0.1878, -0.0997, -0.1096, -0.1465,  0.0285,  0.0828,  0.1252, -0.2863,\n",
      "         -0.2822,  0.2110],\n",
      "        [-0.1804, -0.0824, -0.2193,  0.1858,  0.2338,  0.3051,  0.1669,  0.1092,\n",
      "          0.0737, -0.0153],\n",
      "        [-0.2879,  0.2945, -0.0784,  0.0860, -0.1989,  0.2056,  0.0306,  0.0070,\n",
      "          0.1372, -0.1510],\n",
      "        [-0.0274,  0.0244,  0.1651, -0.2729, -0.2575,  0.0119,  0.2115,  0.0036,\n",
      "         -0.1255,  0.3083],\n",
      "        [ 0.1477,  0.1910, -0.2865, -0.3025, -0.0631, -0.0513, -0.0706,  0.0826,\n",
      "         -0.0244, -0.0690]], requires_grad=True), Parameter containing:\n",
      "tensor([-0.1192,  0.3035,  0.1275, -0.3096, -0.2168], requires_grad=True), Parameter containing:\n",
      "tensor([[-0.0599, -0.0342,  0.2310, -0.1151, -0.3274]], requires_grad=True), Parameter containing:\n",
      "tensor([0.0687], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 初始化模型、损失函数和优化器  \n",
    "model = SimpleNN()                       # 实例化模型  \n",
    "print(list(model.parameters()))  # 确保模型参数非空\n",
    "criterion = nn.MSELoss()                 # 使用均方误差损失函数  \n",
    "optimizer = optim.Adam(model.parameters(), lr=0.01)  # 使用 Adam 优化器，学习率为0.01  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 训练模型  \n",
    "num_epochs = 10  # 设置训练轮数  \n",
    "for epoch in range(num_epochs):  \n",
    "    for batch_X, batch_y in dataloader:  # 遍历 DataLoader  \n",
    "        optimizer.zero_grad()              # 清空梯度  \n",
    "        outputs = model(batch_X)           # 前向传播，得到模型输出  \n",
    "        loss = criterion(outputs, batch_y)  # 计算损失  \n",
    "        loss.backward()                    # 反向传播，计算梯度  \n",
    "        optimizer.step()                   # 使用优化器更新参数  \n",
    "\n",
    "    # 打印每个 epoch 的损失值  \n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')  \n",
    "\n",
    "# 打印训练结束信息  \n",
    "print(\"训练完成！\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorchgpu",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
